Systems and methods for tree-based model inference using multi-party computation

ABSTRACT

A system and method for securely computing an inference of two types of tree-based models, namely XGBoost and Random Forest, using secure multi-party computation protocol. The method includes computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier. Each node has a respective threshold value. The respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value. The method includes computing, based on the respective comparison result, a leaf value associated with the tree classifier, generating a share of the leaf value and transmitting, to the data owner device, a share of the leaf value. The data owner device computes, using a secure multi-party computation and between the model owner device and the data owner device, the leaf value for the respective data of the data owner.

PRIORITY CLAIM

The present application claims priority to U.S. Provisional Application No. 63/241,255, filed Sep. 7, 2021, the content of which is incorporated herein by reference.

The present application is a continuation of U.S. patent application Ser. No. 17/180,475, filed Feb. 19, 2021, which claims priority to U.S. Provisional Application No. 63/020,930, filed on May 6, 2020; and is a continuation-in-part of U.S. application Ser. No. 16/828,085, filed Mar. 24, 2020, which claims priority to U.S. Provisional App. No. 62/948,105, filed on Dec. 13, 2019; and is a continuation-in-part of U.S. application Ser. No. 16/828,216, filed Mar. 24, 2020, which claims priority to U.S. Provisional App. No. 62/948,105, filed on Dec. 13, 2019; and is a continuation-in-part of U.S. application Ser. No. 17/176,530, filed Feb. 16, 2021, which is a continuation of U.S. application Ser. No. 16/828,354, filed Mar. 24, 2020, now U.S. Pat. No. 10,924,460, issued Feb. 16, 2021, which claims priority to U.S. Provisional App. No. 62/948,105, filed on Dec. 13, 2019; and is a continuation-in-part of U.S. application Ser. No. 16/828,420, filed on Mar. 24, 2020, which claims priority to U.S. Provisional App. No. 62/948,105, filed on Dec. 13, 2019, the contents of which are incorporated herein by reference.

The present application is a continuation of U.S. patent application Ser. No. 17/743,887, filed May 13, 2022, the contents of which are incorporated herein by reference.

The present application is a continuation of U.S. patent application Ser. No. 17/742,808, filed May 12, 2022, the contents of which are incorporated herein by reference.

TECHNICAL FIELD

The present disclosure generally relates to a process of allowing a model owner (or a data owner) and another data owner to compute an output of the model on the data such that neither the data owner learns the model nor the model owner (or another data owner) learns anything about the data of the other party.

BACKGROUND

The following details are not considered prior art but an introduction and background to the concepts disclosed herein. XGBoost is an optimized distributed gradient boosting library designed to be efficient, flexible and portable. XGBoost is consists of a set of tree classifiers such that each tree tries to improve the prediction of all previous trees. XGBoost is a popular and efficient open-source implementation of the gradient boosted trees algorithm. Gradient boosting is a supervised learning algorithm, which attempts to accurately predict a target variable by combining the estimates of a set of simpler, weaker models. In one aspect, XGBoost can be considered like any neural network or machine learning model. It gets data as input, it will predict an output. In a tree structure, at each node of the tree it compares a feature of the data with a threshold associated with that node. The system needs to compare the data (data owner private data) with the cut off value at each node of a tree (model owner private data or another data owner private data), but it is not secure to let both parties learn the comparison result as it reveals significant information from the data.

In some cases, the decision trees exist and a secure way to compute an output of the decision tree without revealing the details of the decision tree are needed. In other cases, parties may have private data but desire to work together to train a decision tree without sharing their data. There is no mechanism to enable such a training to occur.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the disclosure can be obtained, a more particular description of the principles briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only exemplary embodiments of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIG. 1 illustrates a federated learning model training approach;

FIG. 2 illustrates a split learning centralized model training approach;

FIG. 3 illustrates a split learning peer-to-peer approach;

FIG. 4 illustrates a blind learning approach;

FIG. 5 illustrates an embodiment related to blind learning;

FIG. 6 illustrates a multi-model intelligence platform according to some aspects of this disclosure;

FIG. 7 illustrates how blind decorrelation works across multiple clients;

FIG. 8 illustrates a method embodiment;

FIG. 9 illustrates a method embodiment;

FIG. 10 illustrates a method embodiment;

FIG. 11 illustrates a group of parties each with private data;

FIG. 12 illustrates a method embodiment

FIG. 13 illustrates another method embodiment;

FIG. 14 illustrates an example tree structure which can be used to understand the principles of the disclosure;

FIG. 15A illustrates a method from the standpoint of a model owner device or a data owner device, according to some aspects of the disclosure;

FIG. 15B illustrates a method from the standpoint of a data owner device, according to some aspects of the disclosure;

FIG. 15C illustrates a method related to how to securely train a decision tree model; and

FIG. 16 illustrates a system embodiment.

INTRODUCTION

Certain aspects and embodiments of this disclosure are provided below. Some of these aspects and embodiments may be applied independently and some of them may be applied in combination as would be apparent to those of skill in the art. In the following description, for the purposes of explanation, specific details are set forth in order to provide a thorough understanding of embodiments of the application. However, it will be apparent that various embodiments may be practiced without these specific details. The figures and description are not intended to be restrictive.

The ensuing description provides example embodiments only, and is not intended to limit the scope, applicability, or configuration of the disclosure. Rather, the following description of the exemplary embodiments will provide those skilled in the art with an enabling description for implementing an exemplary embodiment. It should be understood that various changes may be made in the function and arrangement of elements without departing from the spirit and scope of the application as set forth in the appended claims.

BRIEF DESCRIPTION

As suggested above, it is challenging when using models like the XGBoost model for predicting an output based on input data to keep the model data private and separate from the data owner who provides the data to the model. The approach disclosed herein introduces a process in which multi-party computation can be used to compute a comparison of all nodes in a decision tree and compute a result in an additive share format that enables the decision tree to process the data and keep the data and the model both private from the other parties.

This disclosure will first discuss some background approaches and then introduce the new approaches. In one aspect, a particular platform is used to enable a federated development or training of neural network models. The use of the disclosed platform for training models in this manner is disclosed as another embodiment herein. In yet another embodiment, data is encrypted as it is passed between a server and one or more client devices. Various types of federated learning (Shown in FIG. 1 ), split learning (shown in FIG. 2 ), and split-learning peer-to-peer (Shown in FIG. 3 ) are disclosed herein. This disclosure describes as background two primary improvements over federated learning and split learning. The first is a blind learning approach (shown in FIGS. 4-5 ) in which client side processing occurs in parallel and independent of other clients. The second disclosed approach (shown in FIGS. 6-10 ) relates to a multi-modal artificial intelligence (MMAI) training approach to handle different types of data from different clients. FIGS. 4-13 show background data such as concepts related to blind decorrelation in FIG. 7 , related methods and information regarding how to perform processes in a “shared space” in which parties generate “shares” of their data and rather than sharing data with another party, they provide just a “share” of their data that does not reveal anything regarding their data.

Typical federated learning involves passing a whole model from a server to a client device for training using the client data. The process can include using a number of different clients, each with their respective data, for training purposes. The approach typically is performed in a linear and iterative fashion in which the whole model is sent to the first client with data, then after training at the first client, the whole model is received back to the server for “averaging”. Then whole updated model is sent to second client with data for additional processing. Then that updated model is sent back to the server for additional “averaging”, and so on. In a split learning approach, the model is split and part is sent to each client but there still is a linear and interactive training process that is inefficient. The split-learning peer-to-peer approach also is performed linearly as peer clients share data in the linear process. Improvements in maintaining the privacy of data and efficiency in the training process are needed.

As noted above, a blind learning approach is disclosed as a variation on the typical federated learning approach. A method in this regard includes splitting up, at a server, a neural network into a first portion and a second portion, and sending the second portion separately to a first client and a second client. The clients can have the data (MRIs, patient data, banking data for customers, etc.) and each receive a portion of the neutral network (a certain number of layers of the network up to a cut layer). The method includes performing the following operations until a threshold is met: (1) performing, at the first client and the second client, a forward step on the second portion simultaneously to generate data SA1 and SA2 (See FIGS. 1-4); (2) transmitting, from the first client and the second client, SA1 and SA2 to the server; (3) calculating, at the server, a loss value for the first client and the second client; (4) calculating, at the server, an average loss across the first client and the second client; (5) performing, at the server, backpropagation using the average loss and calculating gradients; and (6) sending, from the server, the gradients to the first client and the second client. This approach provides an improvement over the federated learning approach and the split learning approach by causing the processing on the client side (or the “data server” side) to operate in parallel and independent of each other. This approach also differs from the split learning peer-to-peer approach as well. The independent data servers send their activations up to the server side which aggregates, averages or otherwise processes the data depending on the network requirement to obtain the final trained model.

Another aspect of this disclosure relates to an improvement in developing an artificial intelligence model in which multiple different modes of data or types of data are available to be used for training. For example, different clients might have different types of data. One client might have images of X-rays or MRIs and another client may have text describing a patient's health condition. In this regard, a method can include splitting a neural network into a first client-side network, a second client-side network and a server-side network, sending the first client-side network to a first client. The first client-side network is configured to process first data from the first client, the first data having a first type. The first client-side network can include at least one first client-side layer. The method includes sending the second client-side network to a second client. The second client-side network is configured to process second data from the second client, the second data having a second type. The second client-side network can include at least one second client-side layer, wherein the first type and the second type have a common association.

The method can further include receiving, at the server-side network, first activations from a training of the first client-side network on first data from the first client, receiving, at the server-side network, second activations from a training of the second client-side network on second data from the second client, training at least one server-side layer of the server-side network based on the first activations and the second activations to generate gradients and transmitting the gradients from the server-side network to the first client-side network and the second client-side network. In this manner, multiple different types of data, having a common relationship such as being related to single patient or a single type or category of patient, are used to train the model.

With respect to this present disclosure, the concept of using XGBoost inference using multiparty computation can occur as follows. The first method is typically from the standpoint of a model owner or data owner device and the second method can be from the standpoint of a data owner device.

An example method can include computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier. Each node of the plurality of nodes has a respective threshold value and is associated with a model owner or data owner device. The respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value. There can be two different data owner devices or two different data owners. The respective comparison result does not reveal the respective data to the model owner or data owner device and does not reveal the respective threshold value to the data owner device. The method includes computing, based on the respective comparison result, a leaf value associated with the tree classifier, generating a share of the leaf value and transmitting, from the model owner or data owner device to the data owner device, a share of the leaf value, wherein the data owner device computes, using a secure multi-party computation and between the model owner or data owner device and the data owner device, the leaf value for the respective data of the data owner.

An example system which can be the model owner device can include at least one processor and a computer-readable storage device storing instructions which, when executed by the at least one processor, cause the at least one processor to perform operations. The operations can include computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier, wherein each node of the plurality of nodes has a respective threshold value and is associated with the system, wherein the respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the system and does not reveal the respective threshold value to the data owner device, computing, based on the respective comparison result, a leaf value associated with the tree classifier, generating a share of the leaf value and transmitting, to the data owner device, a share of the leaf value. The data owner device computes, using a secure multi-party computation and between the system and the data owner device, the leaf value for the respective data of the data owner.

A method and system can also represent an embodiment from the standpoint of the data owner device. The method can include transmitting shares of respective data from a data owner device to a model owner or another data owner device, wherein the model owner or other data owner device: (1) computes a respective comparison result of each respective node of a plurality of nodes in a tree classifier based on the shares of the respective data, wherein each node of the plurality of nodes has a respective threshold value and is associated with the model owner or data owner device, wherein the respective comparison result is based on the shares of the respective data being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the model owner or data owner device and does not reveal the respective threshold value to the data owner device; (2) computes, based on the respective comparison result, a leaf value associated with the tree classifier; and (3) generates a share of the leaf value.

The method further includes receiving, from the model owner or one data owner device to the data owner device, a share of the leaf value and computing, using a secure multi-party computation and between the model owner or one data owner device and the data owner device, the leaf value for the respective data of the data owner.

Another aspect of this disclosure is the process of training a decision tree in a secure manner using multiple data sets from different parties. A system and method for computing an outcome of a model operating on data. The method includes computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier to be trained. Each node of the plurality of nodes has a respective threshold value and is associated with a model owner or data owner device. The respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value. The respective comparison result does not reveal the respective data to the model owner or data owner device and does not reveal the respective threshold value to the other data owner device.

The method includes computing, based on the respective comparison result, a leaf value associated with the tree classifier and generating a share of the leaf value and transmitting, from the model owner or one data owner device to the other data owner device, a share of the leaf value. The data owner device computes, using a secure multi-party computation and between the model owner or one data owner device and the other data owner device, the leaf value for the respective data of the other data owner. The process repeats for each node of the decision tree until the best overall threshold values for each node are selected in a process that does not reveal the data of the various participants in the process.

This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used in isolation to determine the scope of the claimed subject matter. The subject matter should be understood by reference to appropriate portions of the entire specification of this patent, any or all drawings, and each claim.

The foregoing, together with other features and embodiments, will become more apparent upon referring to the following specification, claims, and accompanying drawings.

DETAILED DESCRIPTION

Disclosed herein is an approach to enabling a private data owner to be able to provide their data to a model owner and process the data to generate a prediction or an outcome in a manner that preserves privacy between the data owner and the model owner. This disclosure focuses on using multi-party computation and uses the “share” space or “share” world in which an additive or other shared format is provided to compute a comparison result of various nodes within a decision tree and then compute the result in a way that does not reveal threshold values at each node of the decision tree to the data owner nor the respective data values to the model owner. These features are disclosed in FIGS. 14 and 15A, 15B. Another approach is also disclosed in FIG. 15C that relates to a secure process of training a decision tree using secure multi-party computations and that does not reveal private data amongst the parties that are joining together to train the decision tree.

This disclosure first discusses in more detail the federated learning approach, follow by the split learning approach and a split learning peer-to-peer approach and then introduces the federated split-learning approach. Additionally, the multi-modal artificial intelligent (MMAI) learning approach for different types of data is introduced as well. The novel federated split-learning approach and the MMAI approach build on several models including those mentioned above. The application will review these first approaches in more detail and then introduce the novel techniques related to multi-party computation in the context of decision trees in FIG. 14 and FIGS. 15A and 15B as well as FIG. 15C which discusses a training approach for decision trees.

Federated Learning

FIG. 1 illustrates the federated learning approach 100. This is an approach used by major companies now. A downside of this approach is that it proceeds “linearly” to one data provider at a time—rather than in parallel. The example neural network shown is a fully connected feed forward neural network that is being trained using a federated learning approach. The training process in this case includes a server 102 creating a model 104 and sharing the model 106A, 108A and 110A with respective clients 106, 108, 110 in a linear fashion. The clients train the respective model 106A, 108A, 110A separately when they receive the model on their turn and respectively send their trained model data back to the server 102 as shown. The server 102 averages the models and produces a new model 104 with updated weights (a.k.a a trained model). The server 102 sends the new model or weights to the respective clients 106, 108, 110 in a linear fashion. The process is repeated a number of iterations or until a specific accuracy is achieved.

In each iteration, the server 102 averages all participating models to create a trained model B. Thus, the server has a fully-trained model 104 at any point of time. The term “global model” refers to the model that results from the training process. The global model is a trained object that will be used for an inference task. An inference task might be to evaluate a medical image to classify whether the patient has cancer or a broken bone or some other medical condition.

An example of this approach being used, devices such as an electronic watch, or a mobile device, a device charging at night for example, and connected to a Wi-Fi network, could have its processor used to train neural network models. Thus, client 1 (106) could be an Apple watch, client 2 (108) could be another person's iPhone, and so forth. An example of a model is the Siri speech processing service offered by Apple. Every device is training the same model and the only difference is that the respective client is training on the data local to them. The model or data is transmitted back to the server 102 and the server averages the model together. The downside is that respective clients, such as client 1 (106), could be tricked into sharing something about the data being used to train the model. This would be a leakage of privacy data and raise the issued outlined above. The challenge of the federated learning approach is that there is no model privacy as the entire model is passed from client to client. There are high computational costs as each client processes the entire model, and a heavy communication overhead as the entire model is transmitted numerous times. A reconstruction attack can make training data venerable as well.

Split Learning

FIG. 2 illustrates a split learning centralized approach. A model (neural network) 204 is split into two parts: one part (206A, 208A, 210A) resides on the respective client side 206, 208, 210 and includes the input layer to the model and optionally other layers up to a cut layer, and the other part (B) resides on the server side 202 and often includes the output layer. Split layer (S) refers to the layer (the cut layer) where A and B are split. In FIG. 2 , SA represents a split layer or data sent from A to B and SB represents a split layer sent from B to A.

In one example, the neural network between B 204 and client 1 (206) is the B portion 204 plus the A1 portion (206A) with the communication of data SB1 (206C) and SA1 (206B) to complete the entire neural network. The training process is as follows in this model. The server 202 creates A and B and sends a respective model A (206A, 208A, 210A) to the respective client 206, 208, 210. For every client, the operations include repeating the following in a linear or iterative fashion across the group of clients until some conditions occurs. The respective client 206, 208, 210 on their turn downloads the most recent model A from the server 202 (Note that this step is different between the approach shown in FIG. 2 and FIG. 3 .). The clients 206, 208, 210 in their respective turn do a forward step on the model A and sends the output of A (i.e., activations at S only or SA1 (206B), SA2 (208B), SAN 210B)) to the server 202 in addition to the required labels. The server 202 does a forward step on B using the SAs received from the respective client 206, 208, 210. The server 202 calculates the loss function and the server 202 does backpropagation and calculates gradients at the S layer. The server 202 sends the gradients of S only (i.e., SB1 (206C), SB2 (208C), SBN (210C)) to the respective client 206, 208, 210. This is process is performed linearly across the different clients such that the operations occur first for client 206, followed by client 208, and then client 210. The client 206, 208, 210 does backpropagation using the SB gradients received from the server 202 and the client 206, 208, 210 shares their updated A (SA1 (206B), SA2 (208B), SAN (210B)) with the server 202.

The horizontal axis in FIG. 2 is time such that the processing occurs in like a round-robin fashion from client to client.

In one example, network A1 206A on client 1 can include a convolution layer and an activation layer. Having processed data, the client 1 (206) sends the result of that layer forward (SA1 (206B)) to the next layer in the network, which is at the server 202, which calculates the backpropagation and so forth as outlined above. The B network repeatedly (in round robin fashion) processes the different data from the different clients 206, 208, 210. It will ultimately arrive at an averaged reflection of the network. It never trains the network on all the data from all the clients 206, 208, 210 at the same time. It can process data faster and have a benefit of B being averaged across the data as it is built. The final algorithm has not seen all the data. The model B cannot be tricked into revealing its data as it has never been trained on all of the data.

Split Learning in a Peer-to-Peer Environment

FIG. 3 illustrates a split learning peer-to-peer approach. A model (neural network) is split into two parts: one part (A) resides on the client side and includes the input layer, and the other part (B) resides on the server side and often includes the output layer. In FIG. 3 , the client side part (A) is shown respectively as A1 (306A) at client 306, A2 (308A) at client 308, AN (310A) at client 310. A split layer (S) refers to the layer where A and B are split. In FIG. 3 , SA represents a split layer sent from A to B and SB represents a split layer sent from B to A.

In one example, the neural network between B and client 1 306 is the B portion plus the A1 portion 306A with the communication of data SB1 306C and SA1 306B to complete the entire neural network. The training process is as follows in this model. The server 302 creates A and B and sends A to the clients 306, 308, 310. For every client, the process includes repeating the following until some conditions occurs. First, the process includes downloading the most recent A from a previous client.

Note that this step is different between the approach shown in other figures. The process then includes performing a forward step on A and sending the output of A (i.e., activations at S only) to the server 302 in addition to the required labels. The server 302 performs a forward step on B using the SA received from the respective client 306, 308, 310. The server 302 calculates a loss function and performs a backpropagation and calculates gradients at S. The server 302 sends the gradients of S only (i.e., SB) to the respective clients 306, 308, 310. The client does backpropagation using the SB gradients received from the server 302. The client shares their updated A with the server 302.

The peer-to-peer approach generally involves the respective client updating its A model by directly downloading it from a last trained client, or more broadly, by a previously trained client. In this regard, the process of training clients can occur in a round-robin fashion where the clients are trained sequentially. For example, if client 1 306 gets trained first, then in a peer-to-peer model, rather than client 2 308 updating its client-side model A2 from the server 302 or another trusted server, client 2 308 updates its client model A2 by downloaded the client side model A1 from client 1 306. The previously trained model can be the last trained client model or it could be a model from some other previously trained client based on some criteria. For example, client 1 306 and client 2 308 may have their respective models trained. Client 3 310 needs a client-side model update and might implement an algorithm or process to determine which client-side model to download between client 1 306 and client 2 308. Note that the disclosure below implements a multi-model artificial intelligence training process that could apply here. If client 1 306 processes images and its model A1 focuses on image processing, and client 2 308 processes text and its model A2 focuses on text processing, and client 3 310 processes images, then the algorithm or process could cause, in a peer-to-peer environment, the downloading of the client side model A1 to the client 3 310 as its update.

In one scenario, there is not enough information from split learning to achieve proper training of the neural network. It is assumed in this model that a good training approach could be that A and B are aggregated at the server 302 in plain text by simply stacking them (A and B).

Blind Learning

FIG. 4 illustrates the improvement to training neural networks disclosed herein. This improvement can be characterized as a blind learning approach and addresses some of the deficiencies of the approaches disclosed above. FIG. 4 introduces a parallel processing approach. The parallel and independent processing causes the model training to occur at a faster pace than the other models described above.

The blind learning approach does not perform the round robin processing described above. The server 402 splits the network at the “split layer” which is a user parameter inserted into the network definition codes. The “top portion” of the network is kept at the server 402 the “bottom portion” is sent to the respective data providers or clients 406, 408, 410 (the terms clients and data providers are used interchangeably here). The training starts at the very lowest network layer which is the layer closest to the data. Each layer reads either the data (from the first layer) or the output of the previous layer (all other layers).

The layers can calculate their output (these are termed “activations” because they come from an activation function) based on any valid network architecture command (convolutions, dropouts, batch normalization, flatten layers, etc.) and activation function (relu, tanh, etc.). When the last layer on the data side 406, 408, 410 has calculated its appropriate activations (i.e., output) those outputs are sent to the first layer on “the other side of the split”—the first layer on the server side 402.

The following approach involves splitting the model up as before. A model is split into two parts: (A) on the client side and includes the input layer, and (B) on the server side and often includes the output layer. (S) is the split layer. The clients or data providers 406, 408, 410 run independently and send back the answer if they have it. The code on the server 402 processes the data and sends back its output equally to all the clients as SB (406C, 408C, 410C).

An example training process is as follows. The server 402 creates A and B and sends the portion A (406A, 408A, 410A) to the clients 406, 408, 410. The following steps are repeated until a condition is met (e.g., accuracy). All the clients 406, 408, 410 do the forward step on A simultaneously. Up to this point, all the calculations on the clients 406, 408, 410, are being done on independent servers and there is no dependency from one data server to the other. This approach highlights a one of the innovations disclosed herein. All these calculations by the clients/data providers 406, 408, 410 can all operate in parallel, at the same time. This is in contrast to the linear or “round robin” fashion discussed above.

The clients 406, 408, 410 each run their portion A (406A, 408A, 410A) of the neural network and generate a respective output of A (i.e., SA (406B, 408B, 410B) and send the output to the server 402. The server 402 receives 3 different ‘versions’ of the activations (one from each of SA1, SA2, SA3). At this point, the server 402 processes those activations “appropriately”, which can mean that the server 402 does different operations depending on the case. For example, the server 402 calculates the loss value for each client 406, 408, 410 and the server 402 calculates the average loss across all clients. The server 402 performs backpropagation using the average loss and calculates gradients at S. Another example includes the server 402 stacking all received sets of activations from each client 406, 408, 410, generating a global single batch of activations, which is then used by the server 402 to calculate the average loss. The server 402 performs backpropagation using the average loss and calculates gradients at S. The server 402 sends gradients at S (i.e., SB (406C, 408C, 410C)) to all the clients 406, 408, 410.

In other words, training on the server side 402 proceeds much like is described above. Once the first layer on the server side 402 is “complete” (either through averaging or aggregating what is received from the data providers 406, 408, 410) forward propagation occurs until the “top” of the network is reached. An additional innovation described in this disclosure is in the management of the activations coming from the data providers 406, 408, 410 and how they get averaged, aggregated or some other treatment. Once the system arrives at the top of the model, the server 402 calculates the gradients necessary for back propagation, and sends them back down and across the split networks as shown in FIG. 4 .

As noted above, the processing and the management of the activations by the server 402 can vary depending on different factors. For example, assume a case where all three data providers 406, 408, 410 are supplying the same data (X-rays). In that case, the data will be combined horizontally which can conceptually mean that the data is “stacked” one file on top of the other. In this case, the activations that come up will most likely be averaged. The “average of each activation” will then be sent forward into the “top half” of the network.

In a different case, the data can be “vertically” stacked, so Client 1 406 has the first 40 columns of data (say a blood test), Client 2 408 has the next 60 columns of data (say an Electronic Health record that includes data such as age, weight, etc.) and Client 3 410 has the last 100 columns of data (say insurance information—previous claims, etc.). In this instance, the three clients can be considered as establishing a combined “record” of 200 columns (aggregated vertically across the page). In this case, the activations will be “combined vertically” and sent forward into the server network. This and other approaches to combining data can be implemented. Note that the multi-model artificial intelligence model described more fully below builds upon the concept just described with respect to combining vertically the activations. More details will be provided below on this concept.

As noted above, the clients 406, 408,410 run in parallel in this embodiment. This reduces the time it takes to train the model—as all the processing is done in parallel. Further, this data is delivered over a particular platform. The applications incorporated above provide examples of the particular platform that can be used to deliver the data as disclosed herein. This will be discussed more below.

A global model in blind learning can be aggregated as follows. After the training is done, the system uses on the following approach to aggregate a global model, which will be used for the inference task. In a first approach, the server selects one of the models, Ai, to be aggregated with its model, B, to form the global model. The selection of Ai could be achieved using one of the following ways. For example, random selection could be used where the server selects a model (Ai) of any client 406, 408, 410 randomly. This random selection might be influenced by other factors, such as the currently available clients online, the types of data each client processes (text data, image data, temporal data) or based on the transmission speed or network delay between the two entities. The server then stacks both parts Ai and B to generate the global model.

In another example, a weighted client selection could be used. For this selection criteria, the server 402 assigns each client a weight (i.e., a numerical value) that reflects their importance based on their data, computational powers, and other valuable assets they possess and contribute during the training process. For example, a particular model set (say data for a certain language, data associated with a type of image, data associated with a patient set, or data from a particular country or region) could get weighted heavily in the model development. Thus, if a country is selected, then the client devices from that country can be weighted more heavily than clients from other countries. Japanese-based client devices can be used for 80% of the model data, for example. Australia could be 10% and Canada could be the other 10%. In another example, data from a certain clinic associated with an outbreak of the flu or COVID could be weighted more heavily. In yet another example, the type of data might be weighted more heavily as well. Image data may be used for 70% of a model, while textual data for 20% and temporal data for 10%.

Yet another model could be an accuracy-based selection. In this case, the server 402 can test the accuracy generated from each client model Ai and then select the model that generates the “best” accuracy. The “best” can be identified by stakeholders, through a machine learning approach, or otherwise. These are all models of the first approach.

A second approach can be where the global model is aggregated by averaging all clients' models Ai {1, N}. Each client first encrypts their model using homomorphic encryption and then sends the encrypted Ai′ data to the server 402. The server 402 adds all the encrypted models, decrypts the addition results, and then calculates their average. The averaged A is then stacked with B to generate a global model. One approach could be a default approach, and optional approaches could be provided as well. The decryption processes and averaging process could also be spread between different servers, for example, with one process occurring on the client side and another process being performed by the server 402 to achieve the global model.

The approaches may vary through the development of the model. For example, the model may begin to be trained using a default approach and then the training could be adjusted such that a weighted approach is used to complete the model training.

A method example is shown in FIG. 5 and can include splitting up, at a server, a neural network into a first portion and a second portion (502), sending the second portion separately to a first client and a second client (504) and performing the following operations until a threshold is met:

-   -   (1) performing, at the first client and the second client, a         forward step on the second portion simultaneously to generate         data SA1 and SA2;     -   (2) transmitting, from the first client and the second client,         SA1 and SA2 to the server;     -   (3) calculating, at the server, a loss value for the first         client and the second client;     -   (4) calculating, at the server, an average loss across the first         client and the second client;     -   (5) performing, at the server, backpropagation using the average         loss and calculating gradients; and     -   (6) sending, from the server, the gradients to the first client         and the second client (506).

A computing device or devices performing the above operations can also be covered as well as a computer-readable storage device storing instructions which, when executed, cause the processor to perform these operations. The operations can be performed in any order and the method can include one or more of the operations.

In another aspect of this disclosure, the platforms described in the patent applications incorporated above can provide the basis for communicating data back and forth in any of the federated models. For example, each of the clients and/or the server as well may be required to be logged onto a platform or one of the versions of the platform referenced in the applications incorporated herein. Therefore, delivering this functionality over a platform or an exchange configured as disclosed in these applications is also covered as an aspect of this disclosure.

In another aspect, a customer could chose SA, SB lines (vectors and numbers) which represent weights that need to be propagated. If a client wanted their data to be locked down without the server knowing anything about the data, that data can be homomorphically encrypted. The encryption process (which can include any encryption process) could be used in any approach disclosed above.

The incorporated patent applications above provide example platforms that client devices and/or servers can log into or may be required to be logged into in order to perform the blind learning approach disclosed herein.

It is noted that in one aspect, the steps disclosed herein can be practiced by a “system.” The system can include the server and one or more clients together, or might just be functionality performed by the server. The system could also be a client or a group of clients, such as clients in a particular geographic area or clients groups in some manner that are performing the client-based functions disclosed herein. In one aspect, the “server” can also be a computing device (physical or virtual) on the server side as well as a computing device (physical or virtual) on the client side. In one example, a server can be on the client side and can receive back-propagation output of the respective client side models Ai and can synchronize a client-side global model in a round of training.

Thus, each of the server side system and the client side system can perform any one or more of the operations disclosed herein. Claims can be included which outline the steps that occur from the standpoint of any device disclosed herein. For example, the steps of transmission, calculation, and receiving of data can be claimed from the standpoint of a server device, a client device, or group of client devices depending on which embodiment is being covered. All such communication from the standpoint of an individual component or device can be included as within the scope of a particular embodiment focusing on that device.

In another aspect, the system can include a platform as disclosed in the patent applications incorporated by reference also performing steps in coordination with the concept disclosed above. Therefore, the platform as used to provide the blind learning process described herein is also an embodiment of this disclosure and steps can be recited in connection with the use of that platform for training models in a manner that maintains privacy of the data as described herein.

Typically the training of a neural network is performed on similar data types. For example, a neural network trained to identify cancer by receiving a patient image or a kidney is trained on images of kidneys that are and are not cancerous. Next is discussed a new approach to training which uses different types of training data together to train a neural network, using the blind learning approaches disclosed herein.

Multi-Model Artificial Intelligence Approach

As mentioned above, the MMAI innovation builds on the “vertical aggregation” idea described in an example of blind learning. The example related to all three clients 406, 408, 410 providing the same type of data—either images (for stacking) or tabular data to be combined vertically. When the inventors were considering the vertical aggregation concept, they realized that this could be done with different types of data. For example, Client 1 could provide images, Client 2 could provide a blood test, and Client 3 could provide doctors textual notes. The significant difference is all of those data types require different network architectures. In this case, the developers of the system can't define one network and then let the server “split” it. Thus, part of the solution is to let the users define the network “before the split” for each data provider, and then define the network and aggregation technique on the server. This approach is illustrated in FIGS. 6-10 .

FIG. 6 illustrates the multi-modal artificial intelligence (MMAI) platform or a machine learning (ML) platform 600. The MMAI approach reduces the computational requirements and communication overhead of other approaches. Additionally, the training speed is much faster and the process maintains a much higher privacy in the data, including the fact that the model stays private as well.

The MMAI platform 600 applies AI/ML techniques to multiple data types in one large AI model. Typically, different data types require different AI network architectures to yield accurate results. Images, for example, typically require special filters (convolutions), whereas text or speech require different “time series-like” treatment, and tabular data frequently works best with ML or feed forward architectures. The issue is that images are best understood by looking at all of the pixels together and “convoluting” them in various ways, whereas speech is best understood in the context of what came before and/or after a certain sound (i.e. in a manner similar to time-series data), etc. Because of these differences in processing, “state of the art” systems today typically process one data type (i.e. images, text, speech, tabular, etc.).

Most AI researchers recognize that breakthroughs in “next generation” accuracy can be achieved by adding more unique data to their models. This is essentially the equivalent to providing more data to the model to give it more context with which to discover interesting differences in cases. An example of this concept is a model that diagnoses Atrial Fibrillation (A-fib) by examining ECG (electro-cardiogram) data. The model can reach a certain level of accuracy based on the ECG data alone, but when the researchers add age, sex, height and weight to the ECG data, the model becomes far more accurate. The increase in accuracy is due to the four additional data types being able to help the model better understand what would otherwise look to the model like “equivalent” ECGs. Adding the four items or characterizations of the data can make the data more granular.

The MMAI platform 600 shown in FIG. 6 introduces a new generation crypography toolset to improve the training and protection of private data. The MMAI platform 600 provides the model with more data than is typically used to train AI/ML models and expands on the data. The approach adds a significant amount of data by combining different data types—i.e. images and tabular data, for instance.

FIG. 6 illustrates a first outside source of data 602, which is shown as Wells Fargo bank. The Wells Fargo data 602 a is encrypted 602 b and the package of encrypted data 602 c is transmitted to a private AI infrastructure 603. A second outside source of data 604 is shown as Citibank. The Citibank data 604 a is encrypted 604 b and the package of encrypted data 604 c is transmitted to the private AI infrastructure 603. A third outside source of data 606 is shown as from Bank of America. The Bank of America data 606 a is encrypted 606 b and the package of encrypted data 606 c is transmitted to the private AI infrastructure 603. The AI infrastructure 603 includes a first module 608 that will privately explore, select and preprocess all of the data 610 from the disparate sources 602, 604, 606. In this example, all of the sources are identified as banks but they will have different structures for their data, and the respective data can be disparate as well. Of course, it is not a requirement that all of the outside sources 602, 604, 606 of data be of the same type, i.e., banks. The use of banks is just an example. The outside sources 602, 604, 606 could be, for example, a hospital, a clinic, a university, and so forth. The basic concept is that the data types can be different from the various different outside sources 602, 604, 606.

The private AI infrastructure 603 can include a component that privately explores, selects and preprocesses the relevant features from all of the data 602 c, 604 c, 606 c it receives for training. Feature 612 represents the subset of the data 610 which can result from the processing of the component in the private AI infrastructure 603. In operations 614, 616, the AI infrastructure 603 privately trains new deep and statistical models on the selected data 612 and in operation 618 will predict on any private and sensitive data, which can include images, video, text and/or other data types. The AI infrastructure 603 can then sell or grant access to the new models which is presented in operation 620.

FIG. 7 illustrates another variation on the split learning technique 700. This approach provides low compute requirements and low communication overhead to improve the training of models by using a blind decorrelation process for training based on disparate types of data. Building on the A-fib model example above, another source of even more data for the model would be to include a chest X-ray for each case the model considers. Unfortunately, the typical processing of the X-ray image is not consistent with the typical processing of the tabular ECG data. With a few minor engineering additions, the above-disclosed split-federated learning tool can be used to address this incompatibility problem. Namely, new instructions can be provided to the tool to allow different data types to process in the existing pipeline.

In this case rather than an “automatic” split of the network architecture this variation on the idea allows the network architect (i.e. the data scientist developing the algorithm) to specify the specific network components desired for each data type. Each data type will need network architecture layers relevant to its data type (i.e. convolutional layers for images, Recurrent layers/Long Short Term Memory layers for speech, feed forward layers for tabular data, etc.). These disparate layers, each specific to the data type in question, will be specified such that they run on the “data server” side (almost like independent networks in and of themselves). The last layer of each “independent network” (per data type) will send it's activations “across the split” to the “server side”. The algorithm server side will have one consistent “network” that processes the incoming activations (from the data server side) appropriately. In some respects this approach is similar to an “ensemble of networks” (on the data server side) being aggregated into one final network on the algorithm server side (which ultimately produces the final “answer” from the “ensemble” of networks).

Split learning is a collaborative deep learning technique, where a deep learning network or neural network (NN) can be split into two portions, a client-side network A and a server-side network B, as discussed above. The NN includes weights, bias, and hyperparameters. In FIG. 7 , the clients 702, 704, 706, where the data reside, commit only to the client-side portion of the network, and the server 710 commits only to the server-side portion of the network. The client-side and server-side portions collectively form the full network NN.

The training of the network is done by a sequence of distributed training processes. The forward propagation and the back-propagation can take place as follows. With the raw data, a client (say client 702) trains the client-side network 702A up to a certain layer of the network, which can be called the cut layer or the split layer, and sends the activations of the cut layer to the server 710. The server 710 trains the remaining layers of the NN with the activations that it received from the client 702. This completes a single forward propagation step. A similar process occurs in parallel for the second client 704 and its client side network 704A and its data and generated activations which are transmitted to the server 710. A further similar process occurs in parallel for the third client 706 and its client side network 706A and its data and generated activations which are transmitted to the server 710.

Next, the server 710 carries out the back-propagation up to the cut layer and sends the gradients of the activations to the respective clients 702, 704, 706. With the gradients, each respective client 702, 704, 706 performs back-propagation on the remaining network 702A, 704A, 706A. This completes a single pass of the back-propagation between a client 702, 704, 706 and the server 710.

This process of forward propagation and back-propagation continues until the network gets trained with all the available clients 702, 704, 706 and reaches its convergence. In split learning, the architectural configurations are assumed to be conducted by a trusted party that has direct access to the main server 710. This authorized party selects the ML model (based on the application) and network splitting (finding the cut layer) at the beginning of the learning.

As noted above, a concept introduced in this disclosure relates to the clients 702, 704, 706 each providing a different type of data but also where the different types of data have a common association. Thus, the selection of the machine learning model can be based on the types of data that are being processed on the client side, and the process of finding the cut layer can also depend on what types of data or the disparity in the different types of data. For example, for widely disparate data types across the clients 702, 704, 706, the cut layer may be chosen to have more or less layers on the client-side networks 702A, 704A, 706A. In another aspect, the number of layers before the cut layer or split layer may vary across clients. Client 702 may be processing images and require 8 layers before the cut layer, while client 704 may process text and only need 4 layers before the cut layer. In this regard, as long as the vectors, activations or activation layer at the cut layer is consistent across the different clients 702, 704, 706 having different types of data, there is no requirement that the number of layers at the client-side networks 702A, 704A, 706A be the same.

The synchronization of the learning process with multiple clients 702, 704, 706 can be done either in centralized mode or peer-to-peer mode. In the centralized mode, before starting training with the server 710, a client 702, 704, 706 updates its client-side model 702A, 704A, 706A by downloading the model parameters from a trusted third-party server 710, which retains the updated client-side model uploaded by the last trained client. On the other hand, in peer-to-peer mode, the client 702, 704, 706 updates its client-side model by directly downloading it from the last trained client. As noted above, previously-trained models may have a data type similarity to a current client that needs to update its model. For example, the similarity may be based on the data be images, textual data, speech data, video data, temporal data, and so forth. Thus, there may be an intelligent selection of which previously-trained client model to use to download from a peer. The processing by the server 710 can also be split in some cases between some processing on the server side and other processing at a federated server on the client side.

As introduced above, client one 702, client two 704 and client three 706 could have different data types. The server 710 will create two parts of the network and sends one part 702A, 704A, 706A to all the clients 702, 704, 706. The system repeats certain steps until an accuracy condition or other condition is met, such as all the clients sending data to the part of the network that they have, and sends the output to the server 710. The server 710 calculates the loss value for each client and the average loss across all the clients. The server 710 can update its model using a weighted average of the gradients that it computes during back-propagation and sends the gradients back to all the clients 702, 704, 706. The clients 702, 704, 706 receives the gradients from the server 710 and each client 702, 704, 706 performs the back-propagation on their client-side network 702A, 704A, 706A and computes the respective gradients for each client-side-network 702A, 704A, 706A. The respective gradients from the client-side networks 702A, 704A, 706A can then be transmitted back to the server 710 which conducts an averaging of the client-side updates and sends the global result back to all the clients 702, 704, 706.

It is noted that the server 710 functionality can be also broken into several servers that each perform the different operations (such as updating its model by one server and averaging the local client updates by another server, each located in different areas). In the case of FIG. 7 , the clients 702, 704, 706 all process disparate types of data which normally would or could not be processed to develop an AI model.

For example purposes, the A-fib model from above can be used to illustrate the process. Client one 702 could have ECG data, client two 704 could have X-ray data, and client three 706 could have genetic data. Client one 702, for example, could be a hospital, client two 704 could be a medical diagnostics imaging company and client three 706 could be a bank or financial institution, in a manner depicted in FIG. 6 . One of the clients could also have time-based data such as progressive information about the patient relative to weekly visits to the hospital for checkups.

The approach shown in FIG. 7 illustrates how the system can implement new user instructions that allow a user to bring different data types together with the “correct” processing before the split or cut layer or as shown in the blind decorrelation block 708. Each of those parts of the model can be independent, and will operate independently. In one aspect, the processing performed by the blind decorrelation block 708 will result in an activation layer or activations that are transferred to the server 710. This approach is similar to the approach described above with the addition of the differences in data type amongst the clients 702, 704, 706.

The server 710 will combine those activation layers in one of a multitude of ways. The server 710 can average them (which is also described above), but it could also concatenate them into one long activation layer. In another aspect, the server 710 could apply any mathematical function to achieve the desired combination of the activation layers. The server 710 can then process the combined activation layers further using any appropriate network architecture. In one aspect, a server on the client side can receive gradients and average the gradients to generate a global model of the various clients 702, 704, 706 and send the global model to the server 710 for concatenation or for further processing.

The ideas shown in FIGS. 6 and 7 represent an expansion and application of the split-federated learning tool set and provides a platform of off-the-shelf tools to bring disparate data types together into a superset AI model. The processing can be done all privately and the offering can also be included in a marketplace as described in the incorporated patent applications referenced above.

Not only can the system combine different data types, but the system can also combine different AI/ML techniques. For example, client one 702 can be a CNN (convolutional neural network), client two 704 can be an ML routine (i.e. XGBoost), and client 3 706 can apply a different technique as well. In this regard, although the different AI/ML techniques are different, as long as the resulting data at the cut layer is consistent and properly configured, the forward propagation and back propagation can occur and the models can be trained.

In order to assist one of skill in the art to understand how the MMAI approach might work, the following is an example of actual commands per data type coming from the three data providers 702, 704, 706. This code uses the python numbering convention so it starts with builder( ) (tabular data from data provider 1 702). Builder1 in this example is for a CT Scan or image data. The commands would be similar for Xray, MRI, and/or any other picture. Builder2 (from data provider 704) is text data. Note the “lstm” command, which is short for “long/short term memory”. The “server” builder commands define the network that aggregates the other three at the “top” on the other side of the split.

-   -   builder0=tb.NetworkBuilder( )     -   builder0.add_dense_layer(100, 120)     -   builder0.add_relu( )     -   builder0.add_dense_layer(120, 160)     -   builder0.add_relu( )     -   builder0.add_dropout(0.25)     -   builder0.add_dense_layer(160, 200)     -   builder0.add_relu( )     -   builder0.add_split( )     -   builder1=tb.NetworkBuilder( )     -   builder1.add_conv2d_layer(1, 32, 3, 1)     -   builder1.add_batchnorm2d(32)     -   builder1.add_relu( )     -   builder1.add_maxpool2d_layer(2, 2)     -   builder1.add_conv2d_layer(32, 64, 3, 1)     -   builder1.add_batchnorm2d(64)     -   builder1.add_relu( )     -   builder1.add_maxpool2d_layer(2, 2)     -   builder1.add_flatten_layer( )     -   builder1.add_split( )     -   builder2=tb.NetworkBuilder( )     -   builder2.add_lstm_layer(39, 100, batch_first=True)     -   builder2.add_dense_layer(100, 39)     -   builder2.add_split( )     -   server_builder=tb.NetworkBuilder( )     -   server_builder.add_dense_layer(60000, 8000),     -   server_builder.add_relu( )     -   server_builder.add_dense_layer(8000, 1000),     -   server_builder.add_relu( )     -   server_builder.add_dense_layer(1000, 128),     -   server_builder.add_relu( )     -   server_builder.add_dense_layer(128, 1)

FIG. 8 illustrate an example method 800 for providing a MMAI concept from the standpoint of the clients. The method includes receiving a first set of data from a first data source, the first set of data having a first data type (802), training a first client-side network on the first set of data and generating first activations (804), receiving a second set of data from a second data source, the second set of data having a second data type (806) and training a second client-side network on the second set of data and generating second activations (808).

The method can further include transmitting the first activations and the second activations to a server-side network, wherein the server-side network is trained based on the first activations and the second activations to generate gradients (810), and receiving the gradients at the first client-side network and the second client-side network (812). The first data type and the second data type can be different data types, such as one being image-based and the other being textual or temporally based as in speech.

FIG. 9 illustrates an example method 900 from the standpoint of both a server 710 and one or more clients 702, 704, 706. The method can include splitting a neural network into a first client-side network, a second client-side network and a server-side network (902), sending the first client-side network to a first client, wherein the first client-side network is configured to process first data from the first client, the first data having a first type and wherein the first client-side network can include at least one first client-side layer (904), and sending the second client-side network to a second client, wherein the second client-side network is configured to process second data from the second client, the second data having a second type and wherein the second client-side network can include at least one second client-side layer, wherein the first type and the second type have a common association (906).

The method can further include training the first client-side network on first data from the first client and generating first activations (908), transmitting the first activations from the first client-side network to the server-side network (910), training the second client-side network on second data from the second client and generating second activations (912), transmitting the second activations from the second client-side network to the server-side network (914), training at least one server-side layer of the server-side network based on the first activations and the second activations to generate gradients (916) and transmitting the gradients from the server-side network to the first client-side network and the second client-side network (918).

The common association between the disparate types of data can include at least one of a device, a person, a consumer, a patient, a business, a concept, a medical condition, a group of people, a process, a product and/or a service. Any concept, device or person can be the common association or theme of the various disparate types of data that come from different clients and that are processed by different and independent client-side networks up to a cut or split layer. The server-side network can include a global machine learning model. The neural network can include weights, bias and hyperparameters. Hyperparameters typically relate to a parameter whose value is used to control the learning process, such as a topology parameter or a size of a neural network. For example, a learning rate, a mini-batch size, a number of layers on client side, or any parameter related to controlling the process that might impact or relate to different data types can represent a hyperparameter.

The at least one first client-side layer and the at least one second client-side layer each can include a same number of layers or a different number of layers. Because they operate independently, the client-side networks can have a different number of layers as long as they process their data to generate vectors or activations that are in a proper format for passing on to the server-side network for further training. A cut layer can exist between the server-side network and the first client-side network and the second client-side network.

FIG. 10 illustrates an example method 1000 from the standpoint of the server 710. A method can include splitting a neural network into a first client-side network, a second client-side network and a server-side network (1002), sending the first client-side network to a first client, wherein the first client-side network is configured to process first data from the first client, the first data having a first type and wherein the first client-side network can include at least one first client-side layer (1004) and sending the second client-side network to a second client, wherein the second client-side network is configured to process second data from the second client, the second data having a second type and wherein the second client-side network can include at least one second client-side layer, wherein the first type and the second type have a common association (1006).

The method can further include receiving, at the server-side network, first activations from a training of the first client-side network on first data from the first client (1008), receiving, at the server-side network, second activations from a training of the second client-side network on second data from the second client (1010), training at least one server-side layer of the server-side network based on the first activations and the second activations to generate gradients (1012) and transmitting the gradients from the server-side network to the first client-side network and the second client-side network (1014).

Note that in each case, part of the process of the server 710 in terms of training could be perform by the server 710 and other parts such as an averaging of values over the various clients could be performed by a different server (not shown) that could be at a client site, a separate location, or across different clients.

This approach enables the use of the blind learning tool set in a new way that when the system splits up the neural network, at the blind decorrelation 708, the system can make it harder to take the resulting trained model, break it and apply a training inference attack. Because the system can break the neural network in half (or in two portions), and the way it is described above, all that is exchanged from the neural network parts 702A, 704A, 706A is a string or array of numbers, also described as activation layer numbers. Since these are only numbers or an array of characters, what happens at a first neural network portion 702A could be different from what happens at a second neural network portion 704A. For example, the first neural network portion 702A could be 2 layers deep and the second neural network portion 704A could be 90 layers deep. As long as each output resolves to a string of numbers that is structured appropriately for transmission to the top part of the neural network 710, then the forward propagation and the back propagation can work and the training can be achieved. This understanding paves the way for a new concept disclosed herein that different types of data handled across the different portions 702A, 704A, 706A of the neural network can be received and processed properly to train the models( ) If the system can create a different bottom half 702A, 704A, 706A for each of different clients, then the clients 702, 704, 706 don't have to produce or process the same type of data (between text and images, for example), but the properly formatted neural network portions 702A, 704A, 706A can process that disparate data, and produce the structured output that can be sent to the server 710.

In one example, client one 702 might provide a person's ECG, client two 704 can provide a chest X-ray of a heart can client three 706 can provide the genetic profile of the most four interesting proteins in the patient's blood. If the neural network portions 702A, 704A, 706A can process the different respective types of data down to the right vector structure for output, and provide the disparate types of data to the server 710, the server 710 can be configured with the proper neural network to combine all of that information to train a model to be used to make a diagnosis which can utilize the different and disparate types of data.

In one aspect, while the neural network portions 702A, 704A, 706A each process a different type of data, there is some correlating factor associated with the data. In the above example, all of the data may relate generally to the same person, although some data is ECG related and other data is associated with a genetic profile, yet they all are for the same person. Thus, one aspect of this disclosure is that the data does have a common association. In another aspect, the data may not be related to the same person but the common association could be related to an age, gender, race, project, concept, the weather, the stock market, or other factors. All of the data might relate to women between the ages of 30-35, for example. Thus, the common association has some flexibility to how it would be applied.

In another example, the data could be images from a camera of a jet engine stream, another stream of data could be sensor data, and other data could be flight characteristics from an airplane, and the common association could be the airplane. In another aspect, the common association could be a consumer with one type of data being purchasing habits, another type of data being web-surfing patterns, another type of data being emails that the user sends, another type of data being audio from Siri or other speech processing tools, and another type of data being what physical stores the consumer frequents or what is the user's current location. The output of the server could be an advertisement to provide to the user based on the analysis of the disparate types of input. Thus, the common association can relate to any concept that could be used in which disparate types of data can relate to the concept.

A detailed example of how the process of obtaining “shares” of individual private data and then sharing that data between parties is explained with respect to FIGS. 11-13 . The use of shares is part of the approach disclosed herein with respect to averaging the models and thus is important to understand. FIG. 11 illustrates a framework 1100 in which a first party 1102 has example data L₁=[1, 5, 6, 10], a second party 1104 has a respective list of data L₂=[7, 0, 100] and a third party 106 has its private data L₃=[3, 4, 550]. In one example, the various respective lists of data are stored on computer-readable media on various computer systems. Each of the components 1102, 1104, 1106 can represent the respective computer system of the respective party. The component 1108 can represent the shared list which includes each combined list of data from the respective parties 1102, 1104, 1106. Again, the respective lists can be shared over any type of network such as the Internet or a wireless network, cellular network and so forth.

Each party contributed their private lists of data to a combined list of data Si. Si=[0, 1, 3, 4, 5, 6, 7, 20, 100, 550]. Again, in one aspect, this is only in theory and the parties never actually share their data at a location that combined the various lists together. This figure therefore is used to show conceptually how the combined list might exist logically but not physically. The combined list in other words is the combination of the various lists that physically remain private on the computer systems of the various parties. The output of the solution disclosed herein is the Nth smallest value.

The number of participants can be termed “m” and 1≤i≤m. The total numbers in the combined list Si is S=s1+ . . . +sn. The algorithm disclosed herein enables the various parties to securely compute the Nth value of the combined list Si. Note that the approach could be used a number of different times to find various Nth values. Also note that in this example, the data is numerical although in other aspects the data might not be numerical or might be a combination of numerical data and non-numerical data.

Next, several examples shall be provided of the algorithm in practice. Assume in one example that there are the three parties shown in FIG. 11 with data: L1=[1, 5, 6, 10], L2=[7, 0, 100] and L3=[3, 4, 550]. The sorted combined list is S_(i)=[0, 1, 3, 4, 5, 6, 7, 20, 100, 550]. An unsorted list can be W=[1, 5, 6, 20, 7, 01, 100, 3, 4, 550]. The goal is to determine or compute the Nth value in the combined list. Note that the list, if it were sorted as in Si above, that the third position, for example, would have a value of 3. In the example, we'll assume that the goal is to find the value in the third position. The value of N can be set by the participants or in some other fashion.

The value of m is the number of participants which is 3 in this case. The value sj is the number of data in the list belonging to a user j. For example, user 1 has a sj value of 4 and the other two users have a sj value of 3. The value S is the total number of the data s1+s2+ . . . +2m, which in this case is 10.

The SMPC (secure multi-party computation) protocol disclosed herein is equipped with SecureMult and SecureCompare on Ring R. An example of such protocols is found in U.S. patent application Ser. No. 16/828,216, filed on Mar. 24, 2020. The contents of this application are incorporated herein by reference. These are multi-party primitives enabling parties to perform multiplication and comparison securely as would be known by one of skill in the art. A ring is a set equipped with two binary operations and which prevents values from becoming too large. A ring is a set R equipped as noted above with two binary operations which can be +(addition) and * (multiplication) satisfying three sets of axioms called ring axioms. First, R is an abelian group under addition that has a number of requirements. Next, R is a monoid under multiplication with several requirements and third, the multiplication is distributive with respect to addition with several distributivity requirements. One of skill in the art will understand more of the ring structure in math.

In this example Ring R=[Z]264. This means that all the integers from 0 to 264 in the ring. The modulus of the ring is 264. In this example, the maximum value of the ring is 264 and if a number goes above 264, it gets wrapped around and starts over at 1. For example, if the modulus is 7, and a number being processed by the ring results in 11 (such as 5+6), the value would not be 11 because the maximum value of the ring is 7, but the number of would be 4. The reasons for the use of the Ring is to prevent the use of unlimited or infinite numbers when performing the operations disclosed herein.

The protocol or algorithm includes performing a loop of steps until the loop ends on step (5). The first (1) step involves one of the parties creating m additive shares (m−1 shares for other users and 1 for themselves) from their list and distributing them among the other users and themselves. The goal of step (1) is to generate three sets of shares W1, W2, W3 of the set W used for the rest of the process to enable the parties to compute the Nth smallest value of the combined list securely.

To do so, user number i, for each element A in their respective list, generates m−1 random numbers r1, . . . , ri−1, ri+1, . . . , rm−1 (from the Ring) and distributes them between the other parties and sets their own share: ri=A−r1−r2− . . . −ri−1−ri+1 . . . −rm−1.

Note that in step (1), each party computes their additive shares for each value A in their respective lists and shares the (m−1) additive shares (one share of the group of additive shares) to the other parties and computes their own additive share for their own value in the propose position.

This setup is needed to use the SMPC PROTOCOL which uses both the SecureMult and SecureCompare algorithms. See the patent application incorporated above by reference for data on the SecureCompare algorithm and how it works in practice.

In the above example, party 2 has [7, 0, 100]. For each number in the list (say 7 for party 2), the respective party generates 2 random numbers (say 5, −2) and sends r1=5 to party 1 and sends r3=−2 to party 3 and sets his own share r2=7−5−(−2)=4. If the system adds 5, −2 and 4, the result is 7 and that's why this is called additive sharing. This process will be repeated for all numbers in the list. Each party gets only one share of the original value (7). The end of this process, for the one value 7 for the first party, each party's share will be as follows: Part 1 share: 5; Party 2 share: 4; Party 3 share: −2. For each number in each list, each party gets one number as a “share” of that number. If the system repeats the process for all numbers in all lists, each party will end up with S=s1+s2+ . . . +sm shares. S=10 in this example.

In one example, here could be an example of the sets of shares each party would have. If these lists are added, the W=[1, 5, 6, 20, 7, 0, 100, 3, 4, 550] would be obtained: W ₁=[3,0,2,−3,4,5,50,12,8,214] W ₂=[−4,7,3,14,6,4,35,−9,2,150] W ₃=[2,−2,1,9,−10,−2,15,0,−6,186]

Note how for each position, if all the numbers are added, the appropriate value of W is obtained. Such as position 3, in which 2+3+1=6. Each party only has access to the respective list of shares which hides the values of the data from the other parties.

Next in step (2), each party gets a share of a one-hot-code vector V of size S created by a trusted party. The goal of step (2) is to generate three sets of shares V1, V2, V3 associated with a hot-code vector V. Another goal is to select one of the numbers in the list randomly without letting the parties know which number that was selected. In other words, the goal is to select one number from the list of 10 numbers randomly but not tell the party which number they are evaluating. Each party has 10 numbers in their share of the combined list.

The trusted party can have a computer system that performs the operations disclosed herein with the proper security and structure and management to consider being a trusted party. A hot-code vector is a vector consisting of only 0's and a 1 in which there is only a single “1” in the vector with all the other values being zero. In one example, V=[0, 0, 0, 0, 0, 1, 0, 0, 0, 0]. In this example, it is the 6th position in the set of 10 values that is selected. However, how the system selects this number without telling the partis which value is being evaluated. Note that each of these 0's and the 1 is an additive share as defined above. For example, the system can generate randomly three sets of numbers: V ₁=[3,4,5, . . . ] V ₂=[−4,−4,3, . . . ] V ₃=[1,0,−8, . . . ].

The three parties will each get one of the randomly-generated set of numbers V1, V2, V3. The use of these three sets of numbers hides the selected number (the 6th position of V). Note that in the first position, the three shares (3, −4, 1) add up to zero. The second position of the various V1, V2, V3 sets of numbers includes (4, −4, 0) which adds up to zero, the third position adds up to zero as well (5+3−8) and so forth. The sixth position of V has the “1” and the three shares in that case would add up to 1. Each of these sets of numbers is a respective V set. In step (3), each party, with their respective Vi set of numbers computes Ri=Sum(SecureMult(Wi,Vi)). For example, if W1=[3, 0, 2, −3, 4, 5, 50, 12, 8, 214] and V1=[3, 4, 5, 3, −2, 9, 3, 8, 3, −4], then the sum of the secure multiplication of W1 and V1 (W1*V1) is 3*3+0*4+2*5+(−3)*3+ . . . 214*(−4)=R1. Assume in this example that R1=9, R2=17 and R3=−6. These represent a share of a randomly selected number from the sets. There may be more details about how this secure multi-party multiplication operates to obtain these values but at a high level this is how it works. If you add these three numbers (9, 17 and −6), the result is 20.

Note that from the original W=[1, 5, 6, 20, 7, 0, 100, 3, 4, 550], the value of 20 is the in the 8th position of this list or the 8th smallest value. Each party then has a “share” at the end of step (3) of the 8th smallest value in the list or the number 20. None of the parties knows the number 20 but have shares of the number 20.

Note as well that if V=[0, 0, 0, 1, 0, 0, 0, 0, 0, 0] then the actual sum of the secure multiplication of V with W would be [0, 0, 0, 20, 0, 0, 0, 0, 0, 0], or 0+0+0+20+0+0=20. Neither the system nor the parties do this computation as they only have shares of W and V.

Next, step (4) involves running the SecureCompare protocol on Ri and Wi to find the position of Ri in Wi. The parties get a set of V1, V2, V3 or shares of V as part of the SecureCompare protocol.

Each party runs the SecureCompare (Ri, Wi) protocol and gets one share of the final result. The protocol returns the comparison result in “real space”.

In step (5), if N=Pi+1 the protocol stops and returns Ri. In this case, N, the position the parties are trying to determine, is 3 and thus N does not equal 8 and the protocol is not ready to end but moves on to step (6).

Step (6) involves determining if N>Pi+1, which it is not. If it was, the system would remove all numbers smaller than Ri from their shares of W (or their Wi set) and set N=N−(Pi+1). The process would then loop back to step (2) with the smaller number of shares in the respective Wi list.

In step (7), if N<Pi+1, then the system removes all number bigger than or equal to Ri (8) from their shares of W and then returns to step (2). In this case, since 3 is less than 8, for party 1, the new W1 becomes [3, 0, 2, −3, 4, 5, 8] with 50, 12, 214 being removed.

Then, with the new W1, the system now has 7 values in this set and once the steps are performed by each of the three parties, the process starts returns to step (2) with a new set of W1, W2, W3.

FIG. 12 illustrates an example method 1200 embodiment related to the use of shares to determine an Nth smallest value. The method 1200 enables separate parties to compute securely an Nth smallest value in a combined list of values from m number of parties W. In one example, the method is performed across multiple computing devices (an example of which is in FIG. 16 ) in that each party has their own secure computing systems and share data with each other but then perform the computations and comparisons securely on their own systems with the data they receive.

The method 1200 can include (1) creating, by each party of the m parties, m additive shares for each value in a respective list of values for each party of the m parties to yield m lists of additive shares for each party of them parties (1202), (2) distributing, from each party of the m parties, m−1 lists of additive shares from the m lists of additive shares for each party by distributing one of the m−1 lists of additive shares to each other party of the m parties to yield a respective combined list of shares Wi having S values for each of the m parties, wherein S equals the total number of values in the combined list of values from the m parties (1204), (3) receiving, from a trusted party and by each of the m parties, a respective list of additive shares Vi associated with a hot-code vector V comprising a value of 1 randomly assigned a position in V and the rest of the values being 0 (1206), (4) computing, by each party of the m parties and via a SecureMult protocol, Ri=Sum(SecureMult(Wi,Vi,) (1208), (5) applying a comparison protocol to compare, by each party of the m parties, R against all elements in W, such that each party learns a total number of values in W that are smaller than R as a value Pi, where Pi is one share of the total number of values in W that are smaller than R and after combining all Pi values, all parties learn P, wherein a position or R in W is equal to P+1 (1210), (6) when N=P+1, returning, from each party, a value Ri and concluding the method (212), (7) when N>P+1, removing, by each party, all numbers smaller than Ri (and Ri as well) from each party's Wi and setting N=N−(P+1) to yield a new Wi and new N (1214), (8) when N<P+1, removing, by each party, all numbers bigger than Ri (and Ri as well) from Wi to yield a new Wi (1216) and (9) returning to an earlier step such as step (3) (1218). Other secure multiplication and comparison protocols can be used as well other than those listed above for the parties to be able to compute the data they need in a secure way.

The hot-code vector V has a number of values equal to S. This number of values S can change as the method iterates because the respective values of Wi are reduced in iterations which don't end in step (6). In step (7) the respective Wi is reduced where all numbers smaller or equal to Ri are removed and in step (8) it's all numbers bigger than or equal to Ri are removed from Wi. As these operations are performed in the shared space, it is each party operating on their “additive shares” that they received from the other parties and not on the actual raw data. This can be in contrast to “real space” in which the parties are operating on the real data and not additional shares of the data.

The comparison protocol can be the SecureCompare protocol as discussed above. The method can loop or iterate from step (9) to step (3) until N=Pi+1. At that point, the method is done and the value of Ri is returned to the other parties or each respective party knows the value of Ri. Because each party operates in the “shared space” where they are operating on lists of numbers that are “shares” of the actual raw data, each party does not know what numbers are being compared. An owner of a value in the combined list only learns in the end that the value in the combined list W is smaller or bigger than a number the owner of the value does not know from the combined list W. The SecureMult protocol and the SecureCompare protocol operate on a Ring R set equipped with two binary operations. In one example, the Ring R=[Z]264 but other values of the modulus 264 can also be used as needed depending on the application of the method. The SecureMult protocol and the SecureCompare protocol include multi-party computation primitives enabling each party to perform multiplication and comparison securely.

In another example, each party will have a secure and separate computer server or system. The operations disclosed herein can also be considered from eth standpoint of each party's computer and what operations are just performed at that location. A system in this regard can be used for enabling separate parties to compute securely an Nth smallest value in a combined list of values from m number of parties W, the system being operated by one of the parties of the m parties. The system can include a processor and a computer-readable storage device storing instructions which, when executed by the processor, cause the processor to perform operations including (1) creating m additive shares for each value in a respective list of values for each party of the m parties to yield m lists of additive shares for each party of them parties, (2) distributing m−1 lists of additive shares from the m lists of additive shares for each party by distributing one of the m−1 lists of additive shares to each other party of the m parties to yield a respective combined list of shares Wi having S values for each of the m parties, wherein S equals the total number of values in the combined list of values from the m parties, (3) receiving, from a trusted party, a respective list of additive shares Vi associated with a hot-code vector V comprising a value of 1 randomly assigned a position in V and the rest of the values being 0, (4) computing, via a SecureMult protocol, Ri=Sum(SecureMult(Wi,Vi,), (5) applying a comparison protocol to compare R against all elements in W, to learn a total number of values in Wi that are smaller than Ri as a value Pi, wherein Pi values add to equal P and wherein a position or Ri in Wi is equal to Pi+1, (6) when N=P+1, returning a value Ri and concluding the operations, (7) when N>P+1, removing all numbers smaller than Ri (and Ri as well) from each party's Wi and setting N=N−(P+1) to yield a new Wi and new N, (8) when N<P+1, removing all numbers bigger than or equal to Ri from Wi to yield a new Wi and (9) returning to an earlier step such as step (3).

Another method 1300 embodiment is shown in FIG. 13 . This is a broader version of the method of FIG. 12 . In this aspect, a method 1300 is used for determining an Nth smallest value in a list of combined values. The method 1300 includes creating, by each party of a group of m parties, m lists of additive shares associated with each party's respective list of data (1302), distributing, from each party to each other party in the group of m parties, m−1 of the lists of additive shares to yield a respective combined list of additive shares W_(i) obtained by each party of the m parties (1304), receiving from a trusted party a list of additive shares V_(i) associated with a hot-code vector V (1306), computing, in a shared space by each party, a respective R_(i) value using a secure multiplication protocol (1308), comparing, in the shared space, by each party and using secure multi-party comparison protocol, the respective R_(i) to all elements in the respective combined list of additive shares W_(i) to yield a total number P_(i) of values in W_(i) that are smaller than R_(i), wherein adding P_(i) values or shares equals P (1310) and using P to either (1) return R_(i) when N=P+1 and end the method; (2) remove all numbers smaller than R_(i) (and R_(i) as well) from W_(i) and set a new value of N and return to an earlier step in the method until N=P+1; or (3) remove all numbers bigger than R_(i) (and R_(i) as well) from W_(i) and return to an earlier step in the method until N=P+1 (1312).

The method 1300 can be performed be each party's computer system or as a group where various parties perform their portions of the operations of receiving data, distributing data (shares) and performing the multi-party operations to learn about the results of the comparison.

XGBoost Inference Using Multi-Party-Computation

This disclosure now turns to the subject matter of the present claims. FIG. 14 illustrates a tree 1400 have a first node 1402 receives a feature 1 input F1 and a threshold of 14.2. A second node 1404 receives a feature 2 F2 and a threshold of 5. A third node 1406 receives feature 2 F2 and has a threshold of 2.3. A first leaf 1408 has a value of 43, a second leaf 1410 has a value of 11, a third leaf 1412 has a value of 3 and a fourth leaf 1414 has a value of 52.

The way the decision tree works is at each node of the tree, the data owner provides data (a “feature”) which is then evaluated at the node relative to a threshold value. If the feature value is less than the threshold, then the right path of the two paths out of the node is taken. If the feature value is greater than or equal to the threshold value, then the left path out of the node is taken. This proceeds through one or more node layers to a leaf node which has the output value for the data. In the process of providing data to a tree 1400, the data owner may learn about the threshold values, or the paths taken, and thus learn information about the tree (model). The approach disclosed herein keeps the model and data private and separate.

The system needs to compute all nodes first and then multiply the leaf values to a comparison result of the nodes leading to that leaf and sum the result. This is done in an additive share space or additive share format. The goal is to enable the two parties, a model owner or data owner and a data owner (providing the “features” to the tree 1400) to compute the output of the model (the respective leaf value) such that neither the data owner learns about the model nor the model owner (or other data owner) learns about the data. Where there are two data owners, they don't learn about each other's data. The approach is to perform a decision tree inference using multi-party computation primitives such as addition, multiplication and comparison.

In one example, assume a decision tree as shown in FIG. 14 is to predict whether a person is physically “fit”. In this case, there might be a number of different data points or features that might need to be evaluated about the user, such as their height, weight, age, miles run per week, molecule size, and so forth. In more complicated cases, there might be many decision points or “nodes” in the tree that will evaluate data against a respective threshold and cause the tree to proceed down one path or another for the next evaluation node or to a “leaf” where a final determination or prediction is found for whether the person is “fit” or not.

The following example will demonstrate the process with some specific numbers. Assume F1=11 and F2=4. This is the data from the data owner and can represent anything like a height, weight, or other data. The data owner wants to provide this input to the decision tree and compute the output. The output or leaf value would be 3 at L3 because at node 1 1402, F1=11<14.2 a comparison C1=0 and the decision goes to the right to node 3 1406. Thus, since F1(11)<14.2, C1=0 and for the comparison result of node 2 (which does not necessarily matter as the left path is not taken), the C2=0 because F2 (4)<5. The comparison result of node 3, down the right path, is C3=1 because F2>=2.3. Thus, Ci is the comparison result (0, 1) meaning the C1 and C2 comparison results at each node.

At node 2, F2=4 which is >2.3, so the decision goes to the left path arriving at the third leaf 1412 with a value of 3. The model owner or data owner knows the leaf value but the other data owner does not. The model owner or data owner in the example above will not learn anything about the “feature” data, or 11 and 4. The other data owner will not learn about the threshold values of 14.2 and 2.3.

Next, each party will compute a result using secure multi-party computation. This is where each party will not have the L1, L2, L3, C1, C2 or C3 values but only shares of these values. In one example, the parties can use beaver triplets as would understood by those of skill in the art. Each party can use secure multi-party computation to perform the following calculation: Result=L1*C2*C1+L2*(1−C2)*(C1)+L3*(C3)*(1−C1)+L4*(1−C3)*(1−C1)

Thus, for C1=0, C3=1, the result=L3 which is 3. The first term L1*C2*C1 is zero because C1 is zero. The second term L2*(1-C2)*(C1) is zero because C1 is zero. The third term L3*(C3)*(1−C1) is 3*1*1 which is the actual value of L3 and the fourth term L4*(1−C3)*(1−C1) is zero because 1-1=0. The system can compute the result: C1=0 because f1=11 and f2<14.2 and C3=1 because f2>2.3. The result equals: 41*1*0+11*0*0+3*1*1+52*0*1=3 Similarly, applying the values for the other comparison results leads to the other leaf values as well as follows: C1=0;C3=0:result=L4 C1=1;C2=0:result=L2 C1=1;C2=1:result=L1

In the equation above, note that each term includes the leaf value of the leaf, multiplied by the path between the leaf and the previous node, and then multiplied by the next path from that node to the next previous node. If the path was a left path, then the value is the comparison_result. If the decision is to take the right path, then the comparison value is (1−comparison_result). Thus, for the first leaf L1 1408, the first term of the equation is L1*C2*C1, meaning that the leaf value L1 is multiplied by C2 which is the comparison value for a left path between L1 and N2. Next, the path between N2 and N1 is a left path as well, so that value is C1. For L2, the path between L2 1410 and N2 1404 is a right path so the value is L2*(1-C2). Next, the path between N2 1404 and N1 1402 is a left path so the last value is C1. The same pattern follows for L3 and L4 to arrive at the equation above. At the end, each party has one share of the result and the parties can combine the shares to derive the final result.

Typically, the model owner or data owner, who knows the value of the L3 as the value of 3, will send the share of the result to the other data owner. The model owner or data owner does not know anything about the share of the final result. The other data owner receives the share of the result from the model owner or data owner, and then can compute the actual value of the final result but will not know anything about the thresholds or nodes of the decision tree 1400.

This approach can work for one decision tree. In some cases, such as with XGBoost, the approach could use for multiple decision trees. An example XBGoost_result could be r1+r2+ . . . +r_n. Each result could be derived from the method outlined above. Another approach could involve a Random Forest model with n decision trees: rf_result=(r1+r2+ . . . r_n)/n. In this case, the model owner or data owner could just send a share of the total summed result or a share of an average of the total result for the data owner to then calculate according to the secure multi-party computation process the final result.

FIG. 15A illustrates an example method 1500 which occurs from the standpoint of a model owner or data owner device. The method 1500 includes computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier, wherein each node of the plurality of nodes has a respective threshold value and is associated with a model owner or data owner device, wherein the respective comparison result is based on respective data associated with another data owner device being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the model owner or data owner device and does not reveal the respective threshold value to the other data owner device (1502), computing, based on the respective comparison result, a leaf value associated with the tree classifier (1504), generating a share of the leaf value (1506) and transmitting, from the model owner or data owner device to the data owner device, a share of the leaf value, wherein the other data owner device computes, using a secure multi-party computation and between the model owner or data owner device and the other data owner device, the leaf value for the respective data of the other data owner (1508).

The secure multi-party computation can include one or more of an addition, a multiplication and a comparison. Each of the model owner or data owner device and the data owner device can receives share of the respective comparison result. The respective comparison result is either a zero or a one. The step of computing the leaf value can include multiplying the respective comparison result with a respective leaf value associated with a respective node of the plurality of nodes.

In another aspect, computing the leaf value further can include adding together each respective multiplication of the respective comparison result with the respective leaf value associated with a respective node of the plurality of nodes to generate the leaf value.

In one aspect, the method occurs without revealing the set of tree classifiers to the other data owner device and without revealing the data to the model owner or data owner device.

The computing, between the model owner or data owner computing device and the other data owner computing device, of the leaf value of the tree classifier based on the respective comparison result for each of the plurality of nodes can be performed using the secure multi-party computation and beaver triplets.

An example system which can be the model owner or data owner device can include at least one processor and a computer-readable storage device storing instructions which, when executed by the at least one processor, cause the at least one processor to perform operations.

The operations can include computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier, wherein each node of the plurality of nodes has a respective threshold value and is associated with the system, wherein the respective comparison result is based on respective data associated with another data owner device being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the system and does not reveal the respective threshold value to the other data owner device (or in some cases shares some information), computing, based on the respective comparison result, a leaf value associated with the tree classifier, generating a share of the leaf value and transmitting, to the other data owner device, a share of the leaf value, wherein the other data owner device computes, using a secure multi-party computation and between the system and the other data owner device, the leaf value for the respective data of the other data owner.

FIG. 15B illustrates the method from the standpoint of the data owner device. The method 1520 can include transmitting shares of respective data from a data owner device to a model owner or another data owner device, wherein the model owner or other data owner device: (1) computes a secure comparison and a respective comparison result of each respective node of a plurality of nodes in a tree classifier based on the shares of the respective data in a shared space, wherein each node of the plurality of nodes has a respective threshold value and is associated with the model owner or other data owner device, wherein the respective comparison result is based on the shares of the respective data being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the model owner or the other data owner device and does not reveal the respective threshold value to the data owner device (or in another aspect, some information is shared); (2) computes, based on the respective comparison result, a leaf value associated with the tree classifier; and (3) generates a share of the leaf value (1522).

The method further includes receiving, from the model owner or other data owner device to the data owner device, a share of the leaf value (1524) and computing, using a secure multi-party computation and between the model owner or other data owner device and the data owner device, the leaf value for the respective data of the data owner (1526).

Training a Decision Tree

Another aspect of this disclosure is an approach training a decision tree like as is shown in FIG. 14 . What is needed when there is no decision tree 1400 is to train one or in other words to find the threshold values at each node of the decision tree 1400. The following approach allows three or more parties to train a decision tree model securely without learning any significant information about the other party's data set. In this case, assume that a first user U1 has data D1 with three features or a matrix (n1, 3), a second user U2 has data D2 with three features or a matrix (n2, 3) and a third user U3 has data D3 with three features or a matrix (n3, 3). In one example, the D1 data set could be:

F1 F2 F3 p 12 3 4 1 11 2 5 1 10 1 6 0

The values in the right column for the result p (1, 1, 0) are the prediction values which would correspond to the value found in the leaf nodes 1408, 1410, 1412, 1414. For example, if the data was 12, 3 and 4 that represented the three features to be processed in a decision tree the leaf value or prediction should be “1” at the end. Which might relate to whether someone is “fit” or characterized as tall or short or whether they have an illness like cancer. The “1” could mean that they have cancer and a “0” could be that they would not have cancer. Now, each party will have their respective data, and will want to train a model without sharing their data.

Next, the parties will want to come up with proposed threshold values for each node. For example, the first values in each dataset D1 is 12, 11 and 10. These are the “features” that will be provided to the first node 1402 of the decision tree. The next set of numbers, 3, 2, 1 will be input to the next node, and the last set of numbers 4, 5, 9 will again be provided to the next node before the leaf. The party then will determine nominated cut-off or threshold values based on this data. For example, the nominated threshold values could be: F1:(9.5,10.5,11.5,12.5) F2:(0.5,1.5,2.5,3.5) F3:(3.5,4.5,5.6,10)

The nominated cut-off values for the various thresholds can be any numbers but they are typically there to cover all the data numbers so that some proposals are above and some are below. The parties send these nominated thresholds to each other so that each party has a large number of nominated threshold values for each node. Then locally each party on their computing device compute a “Gini” index locally. The Gini index (or coefficient) is a synthetic indicator that captures the level of inequality for a given variable and population. It varies between 0 (perfect equality) and 1 (extreme inequality). Between 0 and 1, the higher the Gini index, the greater the inequality. Each party U1, U2, U3 computes the list of thresholds and shares the actual value to the other parties. This is not in the “shared” space but these are the actual values. The parties then compute the impurity corresponding to each threshold such as, for example, 9.5 which is the first proposed threshold for F1. The question is what would be the impurity value for that proposed threshold for the feature value F1. They are looking for a threshold that separating 1 and 0's in the prediction output. For example, if there is one node in the tree and the proposed threshold is 10.5, then it can be determined that it perfectly separates the 1's and 0's. In other words, with the data and predictions from U1, for F1, the number 10.5 is less than both the number 12 and the number 11, which should both lead to an output of “1” which is correct. The number 10.5 is greater than 10 which should lead to a “0” output. Thus, the proposed threshold of 10.5 for the node of this one-node tree meets the criteria.

If the threshold was 9.5 for the first node, the impurity would be computed and would correspond to that proposed threshold. They are looking for a threshold and feature that separating the 1's and 0's perfectly. For U1, if F1 (the proposed threshold) is 9.5, then the value is (3, 0) (number of ones, number of zeros). For an F1 threshold value of 10.5, it's perfect so the outcome is (2,1) of three good values (1, 1, 0). Thus, this process probes how much impurity is in each proposed threshold value for each proposed feature per node.

The goal is to find a good threshold for each node that works across the various data sets or features. The parties look for a threshold that separates the prediction values between 1's and 0's in the best way overall. The parties will compute the impurity across the various data to determine what the best threshold is. In some case, which of all the proposed thresholds ends up with the best threshold even if they are not perfect. The goal is to find the best feature relate to the best threshold to see how good the thresholds divide the features into the prediction outcomes. If a proposed threshold is perfect, it will align with the p data. We need to check it for all the different thresholds to set the right parameters and so compare.

To train a decision tree, the best cut-off values or threshold values need to be found based on the impurity created by each cut-off value. Impurity could be computed using a Gini index: Gini=p₁(1−p₁)+p₂(1−p₂) where p₁, p₂ are the probability of class 1 and class 2. In the example data set under the prediction column disclosed herein, there are two ones and one zero: (1,1,0). In that case, p1=⅔ and p2=⅓ as example probabilities classes. The impurity should be computed for each possible cut-off for the combined data to get the best result. But because of the desire to maintain privacy in the data, the parties cannot simply combine the data sets. The parties need to compute the probability of each class at each node based on different cut-off values or threshold and then select the cut-off value corresponding to the highest impurity rate. The parties will test different threshold based on their feature values of each user.

U1 may end up with a set of impurity calculations such as F1: (3, 1), F2: (3, 0), F3: (0,0). Assume that there are three parties in the group or n=3. Each party then creates n shares from this data. For example, U1 might create the following shares for (3, 1):

-   -   (12, 4)     -   (14, 3)     -   (−23, −6)

The first column adds to 3 and the second column adds to 1. Thus, these are three additive shares of the impurity calculation (3, 1). The party does the same with generating n shares for each impurity calculation. These shares can be transmitted to the other parties.

U2 may have arrived at F1: (12, 4) for their impurity value for the proposed threshold for F1. U3 may have arrived at F1: (100, 1) for their impurity value for the proposed threshold for F1. For each feature (F1, F2, F3, etc.) each of the users U1, U2, U3 will create n shares of each impurity computation and distribute those shares.

Using secure multi-party computations, each party will add the shares they get for each impurity calculation for each feature for a node. The result may be, for example, for a proposed threshold for F1 to be 9.5 (115, 6). This means that for feature 1, the proposed threshold value of 9.5 produces a total added impurity value of (115, 6). This is the total impurity of the combined data set but does not reveal the dataset. In this case, the impurity has a large number (115) in the first class and a small number (6) on the other class. If the system computes the Gini index, the Gini impurity is 0.094255857 for this threshold. To choose the best threshold, the system can compute the Gini index for all thresholds in the share format and then select the threshold with the minimum Gini value. To do so, the system can computes the minimum in share format using Secure Multi Party Computation techniques. The party will select the best feature and threshold for that node, and then they repeat the process for the next node in the decision tree until the desired depth is reached, which can be predetermined in one example by the participants. So in the Gini equation: p1=115/121 and p2=6/121. The Gini value=0.094255857. The smaller value the better because it means there is less noise.

Thus, in the shared space, each user can determine what the best (perhaps not perfect but the best of the group of data) threshold is for a feature in terms of producing the right output. The process may identify for decision tree 1400 being trained that for node 1 1402, that for feature 1, the best threshold is 9.5 that leads to the right leaf node 1408, 1410, 1416 or 1418 as an output of the decision tree. They use this process to find the best feature and threshold for each node.

FIG. 15C illustrates a method 1570 showing this training approach. As noted, the goal is to train the tree 1400 by finding the threshold values like 14.2 for node 1 1402, the value 2.3 for node 3 1406, and so forth. The process finds the best threshold to get the best or minimum “Gini” value or threshold for the respective node. The method 1570 includes, for each node of a decision tree, publishing, by a first party, a first set of nominated cut-off values at a current node of a decision tree to be trained (1572), computing a first respective impurity distribution value for the first set of nominated cut-off values at the current node (1574), creating first respective n shares of the first respective impurity distribution value (1576), transmitting, from the first party and so a second party, one of the first respective n shares of the first respective impurity distribution value (1576), receiving from the second party one of a second respective n shares of a second respective impurity distribution value (1578), using a secure multi-party computation, adding a group of impurity values to yield a combined impurity value based on the one of the first respective n shares of the first respective impurity distribution value and the one of the second respective n shares of the second respective impurity distribution value (1580) and determining, based on the combined impurity value, a best threshold for the current node (1582). The parties should complete the tree so they can split the data based on a chosen threshold but they also can complete both paths. The process can repeat until the parties reach a desired criteria such as a tree depth, impurity threshold or range, or other criteria.

Note that the claims are drafted from the standpoint of one party that that for n parties, all the parties do the same thing by transmitting shares of their impurity distribution to all the other (n−1) parties. If there are only two parties, then n=2.

The process then proceeds to repeat for the next node in the decision tree until a best threshold and in some cases a best feature for that respective node are selected and the decision tree 1400 becomes trained.

It is possible to train a strong classifier using the boosting technique and a training approach (e.g. decision tree) that produces a weak classifier. The most challenging part is to find the best cut-off value at each node without compromising the data. One alternative approach is to add an extra party (trusted party) which doesn't learn any significant data but they can accelerate the computation and improve the security.

An example system includes at least one processor and a computer-readable storage device storing instructions which, when executed by the at least one processor, cause the at least one processor to perform operations. The system can be one party, the other party, a third party, or a combination of different computing devices of different parties.

The operations can include publishing, by a first party, a first set of nominated cut-off values at a current node of a decision tree to be trained, computing a first respective impurity distribution value for the first set of nominated cut-off values at the current node, creating first respective n shares of the first respective impurity distribution value, transmitting, from the first party and so a second party, one of the first respective n shares of the first respective impurity distribution value, receiving from the second party one of a second respective n shares of the second respective impurity distribution value, using a secure multi-party computation, adding a group of impurity values to yield a combined impurity value based on the one of the first respective n shares of the first respective impurity distribution value and the one of the second respective n shares of the second respective impurity distribution value and determining, based on the combined impurity value, a best threshold for the current node.

Note that both parties in the process will perform the process described above so that all parties publish nominated cut off values.

FIG. 16 illustrates example computer device that can be used in connection with any of the systems disclosed herein. In this example, FIG. 16 illustrates a computing system 1600 including components in electrical communication with each other using a connection 1605, such as a bus. System 1600 includes a processing unit (CPU or processor) 1610 and a system connection 1605 that couples various system components including the system memory 1615, such as read only memory (ROM) 1620 and random access memory (RAM) 1625, to the processor 1610. The system 1600 can include a cache of high-speed memory connected directly with, in close proximity to, or integrated as part of the processor 1610. The system 1600 can copy data from the memory 1615 and/or the storage device 1630 to the cache 1612 for quick access by the processor 1610. In this way, the cache can provide a performance boost that avoids processor 1610 delays while waiting for data. These and other modules can control or be configured to control the processor 1610 to perform various actions. Other system memory 1615 may be available for use as well. The memory 1615 can include multiple different types of memory with different performance characteristics. The processor 1610 can include any general purpose processor and a hardware or software service or module, such as service (module) 1 1632, service (module) 2 1634, and service (module) 3 1636 stored in storage device 1630, configured to control the processor 1610 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. The processor 1610 may be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, etc. A multi-core processor may be symmetric or asymmetric.

To enable user interaction with the device 1600, an input device 1645 can represent any number of input mechanisms, such as a microphone for speech, a touch-sensitive screen for gesture or graphical input, keyboard, mouse, motion input, speech and so forth. An output device 1635 can also be one or more of a number of output mechanisms known to those of skill in the art. In some instances, multimodal systems can enable a user to provide multiple types of input to communicate with the device 1600. The communications interface 1640 can generally govern and manage the user input and system output. There is no restriction on operating on any particular hardware arrangement and therefore the basic features here may easily be substituted for improved hardware or firmware arrangements as they are developed.

Storage device 1630 is a non-volatile memory and can be a hard disk or other types of computer readable media which can store data that are accessible by a computer, such as magnetic cassettes, flash memory cards, solid state memory devices, digital versatile disks, cartridges, random access memories (RAMs) 1625, read only memory (ROM) 1620, and hybrids thereof.

The storage device 1630 can include services or modules 1632, 1634, 1636 for controlling the processor 1610. Other hardware or software modules are contemplated. The storage device 1630 can be connected to the system connection 1605. In one aspect, a hardware module that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as the processor 1610, connection 1605, output device 1635, and so forth, to carry out the function.

In some cases, such a computing device or apparatus may include a processor, microprocessor, microcomputer, or other component of a device that is configured to carry out the steps of the methods disclosed above. In some examples, such computing device or apparatus may include one or more antennas for sending and receiving RF signals. In some examples, such computing device or apparatus may include an antenna and a modem for sending, receiving, modulating, and demodulating RF signals, as previously described.

The components of the computing device can be implemented in circuitry. For example, the components can include and/or can be implemented using electronic circuits or other electronic hardware, which can include one or more programmable electronic circuits (e.g., microprocessors, graphics processing units (GPUs), digital signal processors (DSPs), central processing units (CPUs), and/or other suitable electronic circuits), and/or can include and/or be implemented using computer software, firmware, or any combination thereof, to perform the various operations described herein. The computing device may further include a display (as an example of the output device or in addition to the output device), a network interface configured to communicate and/or receive the data, any combination thereof, and/or other component(s). The network interface may be configured to communicate and/or receive Internet Protocol (IP) based data or other type of data.

The methods discussed above are illustrated as a logical flow diagram, the operations of which represent a sequence of operations that can be implemented in hardware, computer instructions, or a combination thereof. In the context of computer instructions, the operations represent computer-executable instructions stored on one or more computer-readable storage media that, when executed by one or more processors, perform the recited operations. Generally, computer-executable instructions include routines, programs, objects, components, data structures, and the like that perform particular functions or implement particular data types. The order in which the operations are described is not intended to be construed as a limitation, and any number of the described operations can be combined in any order and/or in parallel to implement the processes.

Additionally, the methods disclosed herein may be performed under the control of one or more computer systems configured with executable instructions and may be implemented as code (e.g., executable instructions, one or more computer programs, or one or more applications) executing collectively on one or more processors, by hardware, or combinations thereof. As noted above, the code may be stored on a computer-readable or machine-readable storage medium, for example, in the form of a computer program including a plurality of instructions executable by one or more processors. The computer-readable or machine-readable storage medium may be non-transitory.

The term “computer-readable medium” includes, but is not limited to, portable or non-portable storage devices, optical storage devices, and various other mediums capable of storing, containing, or carrying instruction(s) and/or data. A computer-readable medium may include a non-transitory medium in which data can be stored and that does not include carrier waves and/or transitory electronic signals propagating wirelessly or over wired connections. Examples of a non-transitory medium may include, but are not limited to, a magnetic disk or tape, optical storage media such as compact disk (CD) or digital versatile disk (DVD), flash memory, memory or memory devices. A computer-readable medium may have stored thereon code and/or machine-executable instructions that may represent a procedure, a function, a subprogram, a program, a routine, a subroutine, a module, a software package, a class, or any combination of instructions, data structures, or program statements. A code segment may be coupled to another code segment or a hardware circuit by passing and/or receiving information, data, arguments, parameters, or memory contents. Information, arguments, parameters, data, etc. may be passed, forwarded, or transmitted via any suitable means including memory sharing, message passing, token passing, network transmission, or the like.

In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.

Specific details are provided in the description above to provide a thorough understanding of the embodiments and examples provided herein. However, it will be understood by one of ordinary skill in the art that the embodiments may be practiced without these specific details. For clarity of explanation, in some instances the present technology may be presented as including individual functional blocks including devices, device components, steps or routines in a method embodied in software, or combinations of hardware and software. Additional components may be used other than those shown in the figures and/or described herein. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form in order not to obscure the embodiments in unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail in order to avoid obscuring the embodiments.

Individual embodiments may be described above as a process or method which is depicted as a flowchart, a flow diagram, a data flow diagram, a structure diagram, or a block diagram. Although a flowchart may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be re-arranged. A process is terminated when its operations are completed, but can have additional steps not included in a figure. A process may correspond to a method, a function, a procedure, a subroutine, a subprogram, etc. When a process corresponds to a function, its termination can correspond to a return of the function to the calling function or the main function.

Processes and methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer-readable media. Such instructions can include, for example, instructions and data which cause or otherwise configure a general purpose computer, special purpose computer, or a processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on.

Devices implementing processes and methods according to these disclosures can include hardware, software, firmware, middleware, microcode, hardware description languages, or any combination thereof, and can take any of a variety of form factors. When implemented in software, firmware, middleware, or microcode, the program code or code segments to perform the necessary tasks (e.g., a computer-program product) may be stored in a computer-readable or machine-readable medium. A processor(s) may perform the necessary tasks. Typical examples of form factors include laptops, smart phones, mobile phones, tablet devices or other small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are example means for providing the functions described in the disclosure.

In the foregoing description, aspects of the application are described with reference to specific embodiments thereof, but those skilled in the art will recognize that the application is not limited thereto. Thus, while illustrative embodiments of the application have been described in detail herein, it is to be understood that the inventive concepts may be otherwise variously embodied and employed, and that the appended claims are intended to be construed to include such variations, except as limited by the prior art. Various features and aspects of the above-described application may be used individually or jointly. Further, embodiments can be utilized in any number of environments and applications beyond those described herein without departing from the broader spirit and scope of the specification. The specification and drawings are, accordingly, to be regarded as illustrative rather than restrictive. For the purposes of illustration, methods were described in a particular order. It should be appreciated that in alternate embodiments, the methods may be performed in a different order than that described.

One of ordinary skill will appreciate that the less than (“<”) and greater than (“>”) symbols or terminology used herein can be replaced with less than or equal to (“≤”) and greater than or equal to (“≥”) symbols, respectively, without departing from the scope of this description.

Where components are described as being “configured to” perform certain operations, such configuration can be accomplished, for example, by designing electronic circuits or other hardware to perform the operation, by programming programmable electronic circuits (e.g., microprocessors, or other suitable electronic circuits) to perform the operation, or any combination thereof.

The phrase “coupled to” refers to any component that is physically connected to another component either directly or indirectly, and/or any component that is in communication with another component (e.g., connected to the other component over a wired or wireless connection, and/or other suitable communication interface) either directly or indirectly.

Claim language or other language reciting “at least one of” a set and/or “one or more” of a set indicates that one member of the set or multiple members of the set (in any combination) satisfy the claim. For example, claim language reciting “at least one of A and B” or “at least one of A or B” means A, B, or A and B. In another example, claim language reciting “at least one of A, B, and C” or “at least one of A, B, or C” means A, B, C, or A and B, or A and C, or B and C, or A and B and C. The language “at least one of” a set and/or “one or more” of a set does not limit the set to the items listed in the set. For example, claim language reciting “at least one of A and B” or “at least one of A or B” can mean A, B, or A and B, and can additionally include items not listed in the set of A and B.

Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims.

Claim language reciting “at least one of” a set indicates that one member of the set or multiple members of the set satisfy the claim. For example, claim language reciting “at least one of A and B” means A, B, or A and B. 

What is claimed is:
 1. A method comprising: computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier, wherein each node of the plurality of nodes has a respective threshold value and is associated with a model owner device, wherein the respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the model owner device and does not reveal the respective threshold value to the data owner device and wherein the model owner device differs from the data owner device; computing, based on the respective comparison result, a leaf value associated with the tree classifier, wherein computing the leaf value comprises multiplying the respective comparison result with a respective leaf value associated with a respective node of the plurality of nodes and adding together each respective multiplication of the respective comparison result with the respective leaf value associated with a respective node of the plurality of nodes to generate the leaf value and wherein the data owner device computes, using a secure multi-party computation and beaver triplet between the model owner device and the data owner device, the leaf value for the respective data of the data owner device; generating a share of the leaf value; and transmitting, from the model owner device to the data owner device, the share of the leaf value.
 2. The method of claim 1, wherein the secure multi-party computation comprises one or more of an addition, a multiplication and a comparison.
 3. The method of claim 1, wherein each of the model owner device and the data owner device receives shares of the respective comparison result.
 4. The method of claim 1, wherein the respective comparison result is either a zero or a one.
 5. The method of claim 1, wherein the method occurs without revealing a set of tree classifiers to the data owner device and without revealing the respective data to the model owner device.
 6. A system comprising: at least one processor; and a computer-readable storage device storing instructions which, when executed by the at least one processor, cause the at least one processor to perform operations comprising: computing a respective comparison result of each respective node of a plurality of nodes in a tree classifier, wherein each node of the plurality of nodes has a respective threshold value and is associated with the system, wherein the respective comparison result is based on respective data associated with a data owner device being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the system and does not reveal the respective threshold value to the data owner device and wherein a model owner device differs from the data owner device; computing, based on the respective comparison result, a leaf value associated with the tree classifier, wherein computing the leaf value comprises multiplying the respective comparison result with a respective leaf value associated with a respective node of the plurality of nodes and adding together each respective multiplication of the respective comparison result with the respective leaf value associated with a respective node of the plurality of nodes to generate the leaf value and wherein the data owner device computes, using a secure multi-party computation and beaver triplet between the model owner device and the data owner device, the leaf value for the respective data of the data owner device; generating a share of the leaf value; and transmitting, to the data owner device, a share of the leaf value.
 7. The system of claim 6, wherein the secure multi-party computation comprises one or more of an addition, a multiplication and a comparison.
 8. The system of claim 6, wherein each of the model owner device and the data owner device receives shares of the respective comparison result.
 9. The system of claim 6, wherein the respective comparison result is either a zero or a one.
 10. The system of claim 6, wherein the operations occur without revealing a set of tree classifiers to the data owner device and without revealing the respective data to the model owner device.
 11. A method comprising: transmitting shares of respective data from a data owner device to a model owner device, wherein the model owner device: computes a respective comparison result of each respective node of a plurality of nodes in a tree classifier based on the shares of the respective data, wherein each node of the plurality of nodes has a respective threshold value and is associated with the model owner device, wherein the respective comparison result is based on the shares of the respective data being applied to a respective node having the respective threshold value, wherein the respective comparison result does not reveal the respective data to the model owner device and does not reveal the respective threshold value to the data owner device, and wherein the model owner device differs from the data owner device; computes, based on the respective comparison result, a leaf value associated with the tree classifier, wherein computing the leaf value comprises multiplying the respective comparison result with a respective leaf value associated with a respective node of the plurality of nodes and adding together each respective multiplication of the respective comparison result with the respective leaf value associated with a respective node of the plurality of nodes to generate the leaf value; and generates a share of the leaf value, wherein the data owner device further performs step comprising: receiving, from the model owner device, a share of the leaf value; and computing, using a secure multi-party computation and beaver triplet between the model owner device and the data owner device, the leaf value for the respective data of the data owner device.
 12. The method of claim 11, wherein the secure multi-party computation comprises one or more of an addition, a multiplication and a comparison.
 13. The method of claim 11, wherein each of the model owner device and the data owner device receives shares of the respective comparison result.
 14. The method of claim 11, wherein the respective comparison result is either a zero or a one. 